package com.pai4j.zwiki.service.agent;

import com.pai4j.zwiki.service.LLMService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.nio.file.*;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * 深度代码阅读器（受 Zread 启发）
 * 
 * 核心功能：
 * 1. 逐文件深度阅读 - 让 LLM 仔细阅读每个重要文件
 * 2. 智能提示词 - 根据文件类型使用专门的提示词
 * 3. 上下文管理 - 处理超长文件的分块阅读
 * 4. 文档优先 - 优先分析 README、CONTRIBUTING 等文档
 * 5. 配置理解 - 深度理解配置文件的含义
 * 6. 多轮理解 - 多次调用 LLM 逐步深入理解
 *
 * @author pai4j
 * @since 2025-10-12
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class DeepCodeReader {

    private final LLMService llmService;

    // 代码块最大长度（字符数）- 提升到更大以利用现代LLM的长上下文能力
    private static final int MAX_CHUNK_SIZE = 30000;
    
    // LLM 上下文窗口（预留空间给提示词和响应）- 现代LLM支持更大的上下文
    private static final int CONTEXT_WINDOW = 100000;
    
    // 单个代码文件完整发送的最大大小（字符数）
    private static final int MAX_COMPLETE_FILE_SIZE = 50000;

    /**
     * 执行深度代码阅读
     * 
     * @param workspacePath 项目工作目录
     * @param taskId 任务ID
     * @return 完整的深度阅读报告
     */
    public Map<String, Object> executeDeepReading(String workspacePath, String taskId) {
        log.info("开始执行深度代码阅读（Zread风格）, 任务ID: {}", taskId);

        Map<String, Object> deepReport = new HashMap<>();
        Path projectPath = Paths.get(workspacePath);

        try {
            // 阶段1: 文档层深度阅读
            log.info("阶段1: 深度阅读项目文档");
            Map<String, String> documentAnalysis = readProjectDocuments(projectPath);
            deepReport.put("documentAnalysis", documentAnalysis);

            // 阶段2: 配置文件深度阅读
            log.info("阶段2: 深度理解配置文件");
            Map<String, String> configAnalysis = readConfigurationFiles(projectPath);
            deepReport.put("configAnalysis", configAnalysis);

            // 阶段3: 核心源码文件深度阅读
            log.info("阶段3: 逐文件深度阅读核心源码");
            List<Map<String, Object>> coreFilesAnalysis = readCoreSourceFiles(projectPath);
            deepReport.put("coreFilesAnalysis", coreFilesAnalysis);

            // 阶段4: 依赖与构建文件深度阅读
            log.info("阶段4: 分析构建和依赖配置");
            Map<String, String> buildAnalysis = readBuildFiles(projectPath);
            deepReport.put("buildAnalysis", buildAnalysis);

            // 阶段5: 测试代码深度阅读
            log.info("阶段5: 分析测试代码");
            Map<String, String> testAnalysis = readTestFiles(projectPath);
            deepReport.put("testAnalysis", testAnalysis);

            // 阶段6: 综合理解与总结（让 LLM 基于所有阅读结果进行综合分析）
            log.info("阶段6: 综合理解与总结");
            String comprehensiveUnderstanding = generateComprehensiveUnderstanding(deepReport);
            deepReport.put("comprehensiveUnderstanding", comprehensiveUnderstanding);

            // 阶段7: 关键问题回答（让 LLM 回答关于项目的关键问题）
            log.info("阶段7: 回答关键问题");
            Map<String, String> keyQuestionsAnswers = answerKeyQuestions(deepReport);
            deepReport.put("keyQuestionsAnswers", keyQuestionsAnswers);

            log.info("深度代码阅读完成");

        } catch (Exception e) {
            log.error("深度代码阅读失败", e);
            deepReport.put("error", e.getMessage());
        }

        return deepReport;
    }

    /**
     * 阶段1: 深度阅读项目文档
     */
    private Map<String, String> readProjectDocuments(Path projectPath) throws IOException {
        Map<String, String> analysis = new HashMap<>();

        // 关键文档文件列表
        String[] docFiles = {
            "README.md", "README.MD", "README.txt", "README",
            "CONTRIBUTING.md", "CONTRIBUTING",
            "CHANGELOG.md", "CHANGELOG",
            "LICENSE", "LICENSE.md",
            "ARCHITECTURE.md", "DESIGN.md"
        };

        for (String docFile : docFiles) {
            Path filePath = projectPath.resolve(docFile);
            if (Files.exists(filePath) && Files.isRegularFile(filePath)) {
                String content = Files.readString(filePath);
                
                if (!content.trim().isEmpty()) {
                    log.info("深度阅读文档: {}", docFile);
                    
                    // 使用 LLM 深度理解文档
                    String prompt = buildDocumentReadingPrompt(docFile, content);
                    String llmAnalysis = llmService.generateCodeSummary(prompt);
                    
                    analysis.put(docFile, llmAnalysis);
                }
            }
        }

        return analysis;
    }

    /**
     * 阶段2: 深度理解配置文件
     */
    private Map<String, String> readConfigurationFiles(Path projectPath) throws IOException {
        Map<String, String> analysis = new HashMap<>();

        // 查找配置文件
        String[] configPatterns = {
            "application.yml", "application.yaml", "application.properties",
            "bootstrap.yml", "bootstrap.yaml",
            "application-*.yml", "application-*.yaml",
            ".env", "config.json", "config.yaml"
        };

        Path resourcesPath = projectPath.resolve("src/main/resources");
        if (Files.exists(resourcesPath)) {
            try (Stream<Path> paths = Files.walk(resourcesPath, 3)) {
                List<Path> configFiles = paths
                        .filter(Files::isRegularFile)
                        .filter(p -> {
                            String name = p.getFileName().toString();
                            return name.endsWith(".yml") || name.endsWith(".yaml") || 
                                   name.endsWith(".properties") || name.equals(".env");
                        })
                        .limit(10)
                        .collect(Collectors.toList());

                for (Path configFile : configFiles) {
                    String content = Files.readString(configFile);
                    String relativePath = projectPath.relativize(configFile).toString();
                    
                    log.info("深度理解配置文件: {}", relativePath);
                    
                    // 使用 LLM 深度理解配置
                    String prompt = buildConfigReadingPrompt(relativePath, content);
                    String llmAnalysis = llmService.generateCodeSummary(prompt);
                    
                    analysis.put(relativePath, llmAnalysis);
                }
            }
        }

        return analysis;
    }

    /**
     * 阶段3: 逐文件深度阅读核心源码
     */
    private List<Map<String, Object>> readCoreSourceFiles(Path projectPath) throws IOException {
        List<Map<String, Object>> fileAnalyses = new ArrayList<>();

        // 查找核心源码文件
        Path srcPath = projectPath.resolve("src/main/java");
        if (!Files.exists(srcPath)) {
            return fileAnalyses;
        }

        // 识别核心文件（启动类、主Controller、主Service等）- 增加分析数量以获得更全面的理解
        try (Stream<Path> paths = Files.walk(srcPath)) {
            List<Path> coreFiles = paths
                    .filter(Files::isRegularFile)
                    .filter(p -> p.toString().endsWith(".java"))
                    .filter(this::isCoreFile)
                    .limit(30) // 增加核心文件数量，确保重要文件都被分析
                    .collect(Collectors.toList());

            for (Path javaFile : coreFiles) {
                Map<String, Object> fileAnalysis = deepReadJavaFile(javaFile, projectPath);
                if (fileAnalysis != null) {
                    fileAnalyses.add(fileAnalysis);
                }
            }
        }

        return fileAnalyses;
    }

    /**
     * 深度阅读单个 Java 文件（多轮阅读）
     */
    private Map<String, Object> deepReadJavaFile(Path javaFile, Path projectRoot) {
        Map<String, Object> analysis = new HashMap<>();
        
        try {
            String content = Files.readString(javaFile);
            String relativePath = projectRoot.relativize(javaFile).toString();
            
            analysis.put("filePath", relativePath);
            analysis.put("fileName", javaFile.getFileName().toString());
            analysis.put("fileSize", content.length());

            log.info("深度阅读Java文件: {}", relativePath);

            // 智能分块策略：优先尝试完整发送，只有超大文件才分块
            if (content.length() > MAX_COMPLETE_FILE_SIZE) {
                // 文件超大，使用智能分块阅读
                log.info("文件较大({} 字符)，采用智能分块阅读", content.length());
                List<String> chunks = splitIntoLogicalChunks(content, MAX_CHUNK_SIZE);
                List<String> chunkAnalyses = new ArrayList<>();

                // 第一轮：逐块详细阅读，保留完整代码上下文
                for (int i = 0; i < chunks.size(); i++) {
                    String chunk = chunks.get(i);
                    String prompt = buildCodeChunkReadingPrompt(relativePath, chunk, i + 1, chunks.size());
                    String chunkAnalysis = llmService.generateCodeSummary(prompt);
                    chunkAnalyses.add(chunkAnalysis);
                }

                analysis.put("chunkAnalyses", chunkAnalyses);

                // 第二轮：让 LLM 综合各个块的分析，形成完整理解
                String synthesisPrompt = buildChunkSynthesisPrompt(relativePath, chunkAnalyses);
                String synthesizedAnalysis = llmService.generateCodeSummary(synthesisPrompt);
                analysis.put("synthesizedAnalysis", synthesizedAnalysis);
                
                // 第三轮：基于综合理解回答深度问题
                String deepPrompt = buildDetailedQuestionsPrompt(relativePath, 
                    truncate(content, MAX_CHUNK_SIZE), synthesizedAnalysis);
                String detailedAnalysis = llmService.generateCodeSummary(deepPrompt);
                analysis.put("detailedAnalysis", detailedAnalysis);

            } else {
                // 文件大小适中，完整发送给大模型深度阅读
                log.info("文件大小适中({} 字符)，完整发送进行深度阅读", content.length());
                
                // 第一轮：完整代码的深度阅读
                String prompt = buildCodeFileReadingPrompt(relativePath, content);
                String fileAnalysisText = llmService.generateCodeSummary(prompt);
                analysis.put("fileAnalysis", fileAnalysisText);

                // 第二轮：让 LLM 回答关于该文件的具体问题，传递完整代码
                String detailPrompt = buildDetailedQuestionsPrompt(relativePath, content, fileAnalysisText);
                String detailedAnalysis = llmService.generateCodeSummary(detailPrompt);
                analysis.put("detailedAnalysis", detailedAnalysis);
                
                // 第三轮：让 LLM 从不同角度再次审视代码（安全、性能、可维护性）
                String multiAnglePrompt = buildMultiAngleAnalysisPrompt(relativePath, content, fileAnalysisText);
                String multiAngleAnalysis = llmService.generateCodeSummary(multiAnglePrompt);
                analysis.put("multiAngleAnalysis", multiAngleAnalysis);
            }

        } catch (Exception e) {
            log.error("深度阅读文件失败: {}", javaFile, e);
            analysis.put("error", e.getMessage());
        }

        return analysis;
    }

    /**
     * 阶段4: 分析构建和依赖配置
     */
    private Map<String, String> readBuildFiles(Path projectPath) throws IOException {
        Map<String, String> analysis = new HashMap<>();

        // Maven pom.xml
        Path pomFile = projectPath.resolve("pom.xml");
        if (Files.exists(pomFile)) {
            String content = Files.readString(pomFile);
            log.info("深度分析 pom.xml");
            
            String prompt = buildPomReadingPrompt(content);
            String llmAnalysis = llmService.generateCodeSummary(prompt);
            analysis.put("pom.xml", llmAnalysis);
        }

        // Gradle build.gradle
        Path gradleFile = projectPath.resolve("build.gradle");
        if (Files.exists(gradleFile)) {
            String content = Files.readString(gradleFile);
            log.info("深度分析 build.gradle");
            
            String prompt = buildGradleReadingPrompt(content);
            String llmAnalysis = llmService.generateCodeSummary(prompt);
            analysis.put("build.gradle", llmAnalysis);
        }

        return analysis;
    }

    /**
     * 阶段5: 分析测试代码
     */
    private Map<String, String> readTestFiles(Path projectPath) throws IOException {
        Map<String, String> analysis = new HashMap<>();

        Path testPath = projectPath.resolve("src/test/java");
        if (!Files.exists(testPath)) {
            return analysis;
        }

        try (Stream<Path> paths = Files.walk(testPath, 3)) {
            List<Path> testFiles = paths
                    .filter(Files::isRegularFile)
                    .filter(p -> p.toString().endsWith("Test.java"))
                    .limit(5)
                    .collect(Collectors.toList());

            for (Path testFile : testFiles) {
                String content = Files.readString(testFile);
                String relativePath = projectPath.relativize(testFile).toString();
                
                if (content.length() < MAX_CHUNK_SIZE) {
                    log.info("分析测试文件: {}", relativePath);
                    
                    String prompt = buildTestFileReadingPrompt(relativePath, content);
                    String llmAnalysis = llmService.generateCodeSummary(prompt);
                    analysis.put(relativePath, llmAnalysis);
                }
            }
        }

        return analysis;
    }

    /**
     * 阶段6: 综合理解与总结
     */
    private String generateComprehensiveUnderstanding(Map<String, Object> allAnalysis) {
        StringBuilder contextBuilder = new StringBuilder();
        
        contextBuilder.append("基于对整个项目的深度阅读，现在需要你进行综合理解和总结。\n\n");
        
        // 添加文档分析
        @SuppressWarnings("unchecked")
        Map<String, String> docs = (Map<String, String>) allAnalysis.get("documentAnalysis");
        if (docs != null && !docs.isEmpty()) {
            contextBuilder.append("## 项目文档理解：\n");
            docs.forEach((file, analysis) -> {
                contextBuilder.append(String.format("### %s:\n%s\n\n", file, 
                    truncate(analysis, 500)));
            });
        }

        // 添加配置分析
        @SuppressWarnings("unchecked")
        Map<String, String> configs = (Map<String, String>) allAnalysis.get("configAnalysis");
        if (configs != null && !configs.isEmpty()) {
            contextBuilder.append("## 配置文件理解：\n");
            configs.forEach((file, analysis) -> {
                contextBuilder.append(String.format("### %s:\n%s\n\n", file, 
                    truncate(analysis, 300)));
            });
        }

        // 添加核心文件分析摘要
        @SuppressWarnings("unchecked")
        List<Map<String, Object>> coreFiles = (List<Map<String, Object>>) allAnalysis.get("coreFilesAnalysis");
        if (coreFiles != null && !coreFiles.isEmpty()) {
            contextBuilder.append("## 核心源码理解：\n");
            for (Map<String, Object> file : coreFiles) {
                contextBuilder.append(String.format("### %s:\n", file.get("fileName")));
                Object analysis = file.get("fileAnalysis");
                if (analysis != null) {
                    contextBuilder.append(truncate(analysis.toString(), 300)).append("\n\n");
                }
            }
        }

        String comprehensivePrompt = String.format("""
                %s
                
                请基于以上对项目的深度阅读结果，生成一份综合理解报告，包括：
                
                1. **项目整体定位**：这是一个什么样的项目？解决什么问题？
                2. **核心架构**：采用什么架构设计？有哪些关键设计决策？
                3. **技术选型分析**：为什么选择这些技术栈？有什么优势？
                4. **实现特点**：代码实现有哪些亮点？使用了哪些设计模式或最佳实践？
                5. **潜在问题**：发现了哪些可能的问题或改进空间？
                6. **学习价值**：从这个项目中可以学到什么？
                
                请详细、客观地进行分析（字数：1500-2000字）。
                """, contextBuilder.toString());

        return llmService.generateCodeSummary(comprehensivePrompt);
    }

    /**
     * 阶段7: 回答关键问题
     */
    private Map<String, String> answerKeyQuestions(Map<String, Object> allAnalysis) {
        Map<String, String> answers = new HashMap<>();

        String[] keyQuestions = {
            "这个项目的启动流程是怎样的？从 main 方法开始，程序是如何初始化和运行的？",
            "项目中最核心的业务逻辑在哪里？是如何实现的？",
            "项目采用了哪些设计模式？在哪些地方使用了这些模式？为什么这样设计？",
            "项目的数据流是怎样的？数据是如何在各个层之间流转的？",
            "项目有哪些外部依赖？如何与外部系统交互的？",
            "如果要扩展这个项目，应该从哪里入手？需要注意什么？"
        };

        // 构建上下文摘要
        String contextSummary = buildContextSummaryForQuestions(allAnalysis);

        for (String question : keyQuestions) {
            log.info("让LLM回答关键问题: {}", question);
            
            String questionPrompt = String.format("""
                    基于对项目的深度理解：
                    
                    %s
                    
                    请回答以下问题：
                    %s
                    
                    请给出详细、准确的回答，结合具体的代码和实现细节。
                    """, contextSummary, question);

            String answer = llmService.generateCodeSummary(questionPrompt);
            answers.put(question, answer);
        }

        return answers;
    }

    // ========== 提示词构建方法 ==========

    /**
     * 构建文档阅读提示词
     */
    private String buildDocumentReadingPrompt(String fileName, String content) {
        // 文档通常不会太大，尽量传递完整内容
        String documentContent = content.length() > 30000 ? truncate(content, 30000) : content;
        
        return String.format("""
                请仔细阅读以下项目文档并进行深度分析：
                
                文档名称：%s
                
                文档内容：
                ```
                %s
                ```
                
                请详细分析：
                1. 这份文档的主要内容和目的是什么？
                2. 从文档中能了解到项目的哪些关键信息？
                3. 文档中提到的重要概念、功能、架构是什么？
                4. 有哪些值得注意的细节或特殊说明？
                5. 根据文档，这个项目的技术特点和创新点是什么？
                6. 文档是否提到了项目的设计理念、架构决策或技术选型的原因？
                
                请用中文详细回答（800-1200字），要详细引用文档中的具体内容。
                """, fileName, documentContent);
    }

    /**
     * 构建配置文件阅读提示词
     */
    private String buildConfigReadingPrompt(String fileName, String content) {
        // 配置文件通常不会太大，尽量传递完整内容
        String configContent = content.length() > 20000 ? truncate(content, 20000) : content;
        
        return String.format("""
                请深度分析以下配置文件，这对理解项目架构非常重要：
                
                配置文件：%s
                
                配置内容：
                ```
                %s
                ```
                
                请详细分析：
                1. 这个配置文件配置了哪些内容？请逐项说明每项配置的作用和含义
                2. 从配置中能看出项目使用了哪些技术栈和中间件？（数据库、缓存、消息队列、服务注册等）
                3. 配置体现出的架构特点是什么？是单体应用还是微服务？
                4. 有哪些关键的配置项需要特别注意？为什么这些配置很重要？
                5. 从配置推断，这个项目在生产环境中需要哪些外部依赖和基础设施？
                6. 配置是否体现了一些性能优化或安全加固的措施？
                7. 这些配置选择是否合理？有什么改进建议？
                
                请详细分析（600-1000字），要具体到每个重要的配置项。
                """, fileName, configContent);
    }

    /**
     * 构建代码文件阅读提示词 - 这是最核心的深度阅读
     */
    private String buildCodeFileReadingPrompt(String fileName, String content) {
        // 不截断代码！让LLM完整阅读
        return String.format("""
                请深度阅读并分析以下Java源码文件，这需要你**逐行仔细阅读**全部代码：
                
                文件路径：%s
                文件大小：%d 字符
                
                源代码（完整）：
                ```java
                %s
                ```
                
                请详细分析：
                
                ## 一、整体理解（15%%）
                1. **类的职责**：这个类的核心职责是什么？它在整个系统中扮演什么角色？
                2. **设计意图**：从代码结构和实现来看，设计者的意图是什么？
                
                ## 二、结构分析（20%%）
                3. **类结构**：分析类的结构（字段、方法、内部类等）
                4. **依赖关系**：依赖了哪些类？如何注入的？依赖合理吗？
                5. **继承与接口**：继承或实现了什么？为什么这样设计？
                
                ## 三、核心逻辑深度解析（35%%）
                6. **关键方法逐个分析**：
                   - 请列出所有public方法
                   - 对每个关键方法，详细说明：
                     * 方法的作用和职责
                     * 输入输出和副作用
                     * 核心算法或业务逻辑
                     * 为什么这样实现
                7. **数据流分析**：数据如何进入、处理、输出？
                8. **业务逻辑理解**：实现了什么业务功能？业务规则是什么？
                
                ## 四、技术实现评价（20%%）
                9. **设计模式识别**：使用了哪些设计模式？为什么在这里使用？
                10. **技术亮点**：有哪些值得学习的技术实现？
                11. **代码质量**：命名、注释、结构、可读性如何？
                
                ## 五、问题与建议（10%%）
                12. **潜在问题**：是否存在bug、性能问题、安全隐患？
                13. **改进建议**：如何优化这段代码？
                
                **分析要求**：
                - 必须完整阅读所有代码，不要遗漏任何重要方法
                - 对每个public方法都要进行分析
                - 引用具体的代码行来支撑观点
                - 详细程度：1500-2500字
                
                请开始你的深度分析：
                """, fileName, content.length(), content);
    }

    /**
     * 构建代码块阅读提示词（用于大文件分块）
     */
    private String buildCodeChunkReadingPrompt(String fileName, String chunk, int chunkNum, int totalChunks) {
        return String.format("""
                请阅读以下代码片段（这是文件 %s 的第 %d/%d 部分）：
                
                ```java
                %s
                ```
                
                请分析这部分代码：
                1. 这部分代码主要实现了什么功能？
                2. 有哪些重要的类、方法或逻辑？
                3. 这部分代码的作用和特点是什么？
                
                请简要分析（300-500字）。
                """, fileName, chunkNum, totalChunks, chunk);
    }

    /**
     * 构建块综合提示词
     */
    private String buildChunkSynthesisPrompt(String fileName, List<String> chunkAnalyses) {
        StringBuilder chunksText = new StringBuilder();
        for (int i = 0; i < chunkAnalyses.size(); i++) {
            chunksText.append(String.format("### 第 %d 部分分析：\n%s\n\n", i + 1, chunkAnalyses.get(i)));
        }

        return String.format("""
                以下是对文件 %s 各部分的分析：
                
                %s
                
                请综合以上各部分的分析，生成一个完整的文件理解报告，包括：
                1. 文件的整体功能和职责
                2. 关键实现和重要逻辑
                3. 技术特点和设计亮点
                4. 整体评价
                
                请详细说明（600-1000字）。
                """, fileName, chunksText.toString());
    }

    /**
     * 构建详细问题提示词（第二轮深度提问）
     */
    private String buildDetailedQuestionsPrompt(String fileName, String content, String firstAnalysis) {
        return String.format("""
                关于文件 %s，你已经进行了初步分析：
                
                %s
                
                现在请进行更深入的分析，回答以下问题：
                
                1. **设计决策**：为什么要这样设计？有什么考虑？
                2. **实现细节**：关键算法或业务逻辑的具体实现原理是什么？
                3. **异常处理**：代码中如何处理异常和边界情况？
                4. **性能考虑**：有哪些性能优化的考虑？
                5. **扩展性**：如果要扩展功能，应该如何修改？
                
                请结合代码详细回答（每个问题100-200字）。
                """, fileName, firstAnalysis);
    }

    /**
     * 构建 pom.xml 阅读提示词
     */
    private String buildPomReadingPrompt(String content) {
        // POM文件通常不会超大，尽量传递完整内容
        String pomContent = content.length() > 30000 ? truncate(content, 30000) : content;
        
        return String.format("""
                请深度分析以下 Maven pom.xml 配置文件，这对理解项目的技术栈和架构至关重要：
                
                ```xml
                %s
                ```
                
                请详细分析：
                
                ## 一、项目基本信息（10%%）
                1. **项目标识**：groupId、artifactId、version、packaging 等基本信息说明了什么？
                2. **项目类型**：从配置看，这是什么类型的项目？
                
                ## 二、依赖深度分析（40%%）
                3. **Spring Boot 生态**：
                   - Spring Boot 版本是多少？
                   - 使用了哪些 Spring Boot Starter？
                   - 每个 Starter 的作用是什么？
                
                4. **数据访问层**：
                   - 使用了什么持久化框架？（MyBatis/JPA/Hibernate）
                   - 数据库驱动是什么？
                   - 是否有数据库连接池配置？
                
                5. **服务治理**：
                   - 是否使用了Spring Cloud组件？
                   - 有哪些微服务相关的依赖？（如注册中心、配置中心、网关等）
                
                6. **其他关键依赖**：
                   - 缓存：Redis等
                   - 消息队列：RocketMQ、Kafka等
                   - 工具库：Lombok、Hutool等
                   - 请逐个说明重要依赖的作用
                
                ## 三、构建配置（20%%）
                7. **构建插件**：使用了哪些Maven插件？各有什么作用？
                8. **编译配置**：Java版本、编码等配置
                9. **打包方式**：如何打包部署？
                
                ## 四、技术栈总结（20%%）
                10. **完整技术栈**：基于依赖，总结项目的完整技术栈
                11. **架构推断**：从依赖推断，这是什么架构？（单体/微服务/分布式）
                12. **技术选型评价**：这些技术选型是否合理？有什么优势和注意事项？
                
                ## 五、潜在问题（10%%）
                13. **版本冲突**：是否可能存在版本冲突？
                14. **改进建议**：依赖管理有什么可以改进的地方？
                
                请详细分析（1200-1800字），要具体到每个重要的依赖。
                """, pomContent);
    }

    /**
     * 构建 build.gradle 阅读提示词
     */
    private String buildGradleReadingPrompt(String content) {
        return String.format("""
                请深度分析以下 Gradle 构建配置：
                
                ```gradle
                %s
                ```
                
                请分析：
                1. 项目的依赖和技术栈
                2. 构建配置的特点
                3. 使用的插件和工具
                4. 整体技术选型评价
                
                请详细说明（400-600字）。
                """, truncate(content, 5000));
    }

    /**
     * 构建测试文件阅读提示词
     */
    private String buildTestFileReadingPrompt(String fileName, String content) {
        return String.format("""
                请分析以下测试代码：
                
                文件：%s
                
                ```java
                %s
                ```
                
                请分析：
                1. 这个测试测试了什么功能？
                2. 使用了哪些测试框架和工具？
                3. 测试覆盖了哪些场景？
                4. 测试代码的质量如何？
                
                请简要分析（200-400字）。
                """, fileName, truncate(content, 5000));
    }
    
    /**
     * 构建多角度分析提示词（第三轮深度分析）
     */
    private String buildMultiAngleAnalysisPrompt(String fileName, String content, String previousAnalysis) {
        return String.format("""
                关于文件 %s，你已经进行了初步分析：
                
                %s
                
                现在请从以下几个专业角度进行深度分析，每个角度都要详细展开：
                
                ## 角度一：安全性分析
                1. 这段代码是否存在安全隐患？（如SQL注入、XSS、权限漏洞等）
                2. 敏感数据是否得到适当保护？
                3. 输入验证是否充分？
                4. 有哪些安全最佳实践被遵循或被忽略？
                
                ## 角度二：性能分析
                1. 代码的时间复杂度和空间复杂度如何？
                2. 是否存在明显的性能瓶颈？（如N+1查询、不必要的循环等）
                3. 资源使用是否合理？（如连接池、内存管理）
                4. 有哪些性能优化的机会？
                
                ## 角度三：可维护性分析
                1. 代码的可读性如何？命名是否清晰？
                2. 是否遵循SOLID原则和设计模式？
                3. 代码的耦合度和内聚性如何？
                4. 如果要修改或扩展功能，容易吗？
                
                ## 角度四：健壮性分析
                1. 异常处理是否完善？
                2. 边界条件是否被考虑？
                3. 并发安全性如何？
                4. 是否有容错机制？
                
                ## 角度五：最佳实践评估
                1. 代码是否遵循了该语言/框架的最佳实践？
                2. 有哪些值得学习的优秀实践？
                3. 有哪些反模式需要改进？
                
                请详细分析（每个角度200-300字，总计1000-1500字）。
                
                完整代码：
                ```java
                %s
                ```
                """, 
                fileName, 
                truncate(previousAnalysis, 800),
                content // 传递完整代码，不截断
        );
    }

    // ========== 辅助方法 ==========

    /**
     * 判断是否为核心文件
     */
    private boolean isCoreFile(Path file) {
        String fileName = file.getFileName().toString();
        String pathStr = file.toString();
        
        // 启动类
        if (fileName.contains("Application.java") && !pathStr.contains("/test/")) {
            return true;
        }
        
        // Controller
        if (fileName.endsWith("Controller.java") && !pathStr.contains("/test/")) {
            return true;
        }
        
        // Service
        if (fileName.endsWith("Service.java") && !pathStr.contains("/test/") && 
            !fileName.endsWith("ServiceImpl.java")) {
            return true;
        }
        
        // Config
        if (fileName.endsWith("Configuration.java") || fileName.endsWith("Config.java")) {
            return true;
        }
        
        return false;
    }

    /**
     * 将长文本分块（保留向后兼容）
     */
    private List<String> splitIntoChunks(String text, int chunkSize) {
        return splitIntoLogicalChunks(text, chunkSize);
    }
    
    /**
     * 智能分块：按照代码逻辑结构分块，而不是简单按字符数
     * 尽量保持类、方法的完整性
     */
    private List<String> splitIntoLogicalChunks(String text, int chunkSize) {
        List<String> chunks = new ArrayList<>();
        String[] lines = text.split("\n");
        StringBuilder currentChunk = new StringBuilder();
        int braceDepth = 0;
        int lastClassOrMethodLine = 0;
        
        for (int i = 0; i < lines.length; i++) {
            String line = lines[i];
            String trimmedLine = line.trim();
            
            // 跟踪大括号深度，用于判断代码块边界
            braceDepth += countChar(line, '{') - countChar(line, '}');
            
            // 检测类或方法定义的开始
            if (trimmedLine.matches("^(public|private|protected|class|interface|enum)\\s+.*\\{?$") 
                || trimmedLine.startsWith("@")) {
                lastClassOrMethodLine = i;
            }
            
            // 如果当前块已经足够大，且到达了一个完整的代码块边界（braceDepth回到0）
            if (currentChunk.length() + line.length() > chunkSize 
                && currentChunk.length() > 0 
                && braceDepth == 0 
                && i - lastClassOrMethodLine > 5) { // 确保不是在方法中间
                
                chunks.add(currentChunk.toString());
                currentChunk = new StringBuilder();
            }
            
            currentChunk.append(line).append("\n");
        }
        
        if (currentChunk.length() > 0) {
            chunks.add(currentChunk.toString());
        }
        
        // 如果分块失败（比如单个方法就超过chunkSize），回退到简单分块
        if (chunks.isEmpty() && text.length() > 0) {
            chunks.add(text);
        }
        
        return chunks;
    }
    
    /**
     * 计算字符串中某个字符出现的次数
     */
    private int countChar(String str, char ch) {
        return (int) str.chars().filter(c -> c == ch).count();
    }

    /**
     * 截断文本
     */
    private String truncate(String text, int maxLength) {
        if (text == null) return "";
        if (text.length() <= maxLength) return text;
        return text.substring(0, maxLength) + "...[已截断]";
    }

    /**
     * 为问答构建上下文摘要
     */
    private String buildContextSummaryForQuestions(Map<String, Object> allAnalysis) {
        StringBuilder summary = new StringBuilder();
        
        summary.append("## 项目理解摘要\n\n");
        
        // 文档摘要
        @SuppressWarnings("unchecked")
        Map<String, String> docs = (Map<String, String>) allAnalysis.get("documentAnalysis");
        if (docs != null && docs.containsKey("README.md")) {
            summary.append("### README:\n").append(truncate(docs.get("README.md"), 400)).append("\n\n");
        }
        
        // 配置摘要
        @SuppressWarnings("unchecked")
        Map<String, String> configs = (Map<String, String>) allAnalysis.get("configAnalysis");
        if (configs != null && !configs.isEmpty()) {
            summary.append("### 配置要点:\n");
            configs.values().stream().limit(2).forEach(v -> 
                summary.append(truncate(v, 200)).append("\n")
            );
            summary.append("\n");
        }
        
        // 综合理解
        String comprehensive = (String) allAnalysis.get("comprehensiveUnderstanding");
        if (comprehensive != null) {
            summary.append("### 综合理解:\n").append(truncate(comprehensive, 800)).append("\n\n");
        }
        
        return summary.toString();
    }
}

